import WebsocketClass from '@utils/websocket'
import { getWebsocketOrigin } from '@utils'
import { WebsocketMapping } from '@enums'
import { WEBSOCKET_TYPE } from '@enums/websocket'

// 控制是否启用加密通信
const ENABLE_ENCRYPTION = import.meta.env.VITE_ENABLE_ENCRYPTION === 'true'

export const useWebsocketStore = defineStore('websocket', {
  state: () => ({
    response: null,
    socket: null,
    encrypted: ENABLE_ENCRYPTION // 记录当前是否启用加密
  }),
  getters: {},
  actions: {
    /**
     * 初始化websocket
     */
    init() {
      if (!this.socket) {
        const authStore = useAuthStore()
        const token = authStore?.token
        // 如果没有 token，不初始化 WebSocket
        if (!token) {
          return
        }
        
        const wsOrigin = getWebsocketOrigin()
        
        // 直接使用 WebsocketMapping.WEBSOCKET
        const wsPath = WebsocketMapping.WEBSOCKET
        
        
        const url = `${wsOrigin}${wsPath}/${token}`
        console.log('🌐 WebSocket 加密状态:', this.encrypted ? '启用' : '禁用')
        
        try {
          // 如果存在旧的socket实例，先关闭它
          if (this.socket) {
            try {
              this.socket.close()
            } catch (error) {
              console.error('🌐 关闭旧WebSocket实例失败:', error)
            }
            this.socket = null
          }
          
          this.socket = new WebsocketClass(url, data => {
            // 根据消息类型打印不同的日志，但不打印具体消息内容
            if (data && data.type === WEBSOCKET_TYPE.HEARTBEAT) {
              console.log('🌐 WebSocket 收到心跳消息')
              return
            }
            
            // 查找消息类型名称
            const typeEntry = Object.entries(WEBSOCKET_TYPE).find(([_, value]) => value === data.type)
            const typeName = typeEntry ? typeEntry[0] : '未知类型'
            
            console.log(`🌐 WebSocket 收到 ${typeName}(${data.type}) 类型的消息`)
            this.response = data
          }, this.encrypted) // 传递加密控制参数
          
          // 添加连接状态检查和重试机制
          let connectionCheckCount = 0
          const connectionCheck = setInterval(() => {
            connectionCheckCount++
            
            if (this.socket && this.socket.status === 1) {
              console.log('🌐 WebSocket 连接状态检查: 已连接')
              
              // 如果连接稳定，清除检查定时器
              if (this.socket.connectionStable || connectionCheckCount > 5) {
                console.log('🌐 WebSocket 连接已稳定，停止状态检查')
                clearInterval(connectionCheck)
              }
            } else {
              console.warn('🌐 WebSocket 连接状态检查: 未连接')
              
              // 尝试重新连接，但最多尝试5次
              if (connectionCheckCount <= 5) {
                console.log(`🌐 WebSocket 尝试重新连接... (第${connectionCheckCount}次)`)
                if (this.socket) {
                  this.socket.connect()
                }
              } else {
                console.error('🌐 WebSocket 连接检查超过最大次数，停止检查')
                clearInterval(connectionCheck)
                
                // 最后一次尝试完全重新初始化
                if (this.socket) {
                  this.socket.close()
                  this.socket = null
                  
                  // 延迟3秒后重新初始化
                  setTimeout(() => {
                    console.log('🌐 WebSocket 最后尝试完全重新初始化')
                    this.init()
                  }, 3000)
                }
              }
            }
          }, 5000) // 每5秒检查一次
          
          this.socket.connect()
        } catch (error) {
          console.error('🌐 WebSocket 初始化错误:', error)
          this.socket = null
        }
      } else {
        console.log('�� WebSocket 已经初始化')
        
        // 检查连接状态，如果未连接则尝试重连
        if (this.socket.status !== 1) {
          console.log('🌐 WebSocket 已初始化但未连接，尝试重新连接')
          this.socket.connect()
        }
      }
    },
    /**
     * 发送信息
     * @param {*} data
     */
    send(params) {
      if (!this.socket) {
        console.warn('🌐 WebSocket 未初始化，无法发送消息')
        return
      }
      this.socket.send(params)
    },
    /**
     * 手动断开websocket
     */
    close() {
      if (this.socket) {
        this.socket.close()
      }
      this.response = null
      this.socket = null
    },
    /**
     * 切换加密状态（仅用于开发测试）
     */
    toggleEncryption() {
      this.encrypted = !this.encrypted
      console.log('🌐 WebSocket 加密状态已切换为:', this.encrypted ? '启用' : '禁用')
      // 重新初始化WebSocket
      this.close()
      this.init()
    },
    /**
     * 重新初始化WebSocket
     */
    reinitialize() {
      console.log('🌐 WebSocket 开始重新初始化')
      // 关闭现有连接
      this.close()
      // 重新初始化
      this.init()
      
      // 返回初始化状态
      return {
        initialized: !!this.socket,
        encrypted: this.encrypted,
        active: this.socket?.isEncrypted || false
      }
    }
  }
})
